{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Python：jieba库的介绍与使用\n",
    "\n",
    "## **前言：**\n",
    "\n",
    "jieba是优秀的中文分词第三方库，由于中文文本之间每个汉字都是连续书写的，我们需要通过特定的手段来获得其中的每个词组，这种手段叫做分词，我们可以通过jieba库来完成这个过程。\n",
    "\n",
    "\n",
    "\n",
    "## 一、jieba库基本介绍\n",
    "\n",
    "(1)jieba库概述\n",
    "\n",
    "① jieba是优秀的中文分词第三方库\n",
    "\n",
    "②中文文本需要通过分词获得单个的词语\n",
    "\n",
    "③ jieba是优秀的中文分词第三方库，需要额外安装           \n",
    "\n",
    "④jieba库提供三种分词模式，最简单只需掌握一个函数\n",
    "\n",
    " (2)jieba分词的原理\n",
    "\n",
    "① 分词依靠中文词库\n",
    "\n",
    "② 利用一个中文词库，确定汉字之间的关联概率\n",
    "\n",
    "③ 汉字间概率大的组成词组，形成分词结果\n",
    "\n",
    "④ 除了分词，用户还可以添加自定义的词组\n",
    "\n",
    "## 二、jieba库使用说明\n",
    "\n",
    " (1)jieba分词的三种模式\n",
    "\n",
    "       精确模式、全模式、搜索引擎模式"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "①jieba.cut(s)精确模式：就是把一段文本精确地切分成若干个中文单词，若干个中文单词之间经过组合，就精确地还原为之前的文本。其中不存在冗余单词。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "中国,是,一个,伟大,的,国家,"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "s = \"中国是一个伟大的国家\"\n",
    "for i in jieba.cut(s, cut_all=False, use_paddle=True):\n",
    "    print(i, end=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "② jieba.lcut(s,cut\\_all=True) 全模式：把文本中所有可能的词语都扫描出来，有冗余:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['中国', '国是', '一个', '伟大', '的', '国家']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"中国是一个伟大的国家\"\n",
    "jieba.lcut(s, cut_all=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "\n",
    "③jieba.lcut\\_for\\_search(s) 搜索引擎模式：在精确模式基础上，对长词再次切分:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "中华,中华人民,中华人民共和国,华人,人民,人民共和国,共和,共和国,"
     ]
    }
   ],
   "source": [
    "s = \"中华人民共和国\"\n",
    "for i in jieba.cut(s, cut_all=True, use_paddle=True):\n",
    "    print(i, end=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['中华', '华人', '人民', '共和', '共和国', '中华人民共和国']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"中华人民共和国\"\n",
    "jieba.lcut_for_search(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "### 三、jieba库的安装\n",
    "\n",
    "因为 jieba 是一个第三方库，所有需要我们在本地进行安装：\n",
    "\n",
    "ⅠIDLE中jieba库的安装：\n",
    "\n",
    "Windows 下使用命令安装：在联网状态下，在命令行下输入 pip\n",
    "\n",
    "install jieba 进行安装，安装完成后会提示安装成功。具体过程如图：\n",
    "\n",
    "①  Win + r 打开运行框并输入cmd打开指令框：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-e3398fefefe2ed50.png)\n",
    "\n",
    "②在指令框输入“pip install jieba”并按下回车等待下载：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-eac424490162784d.png)\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-799b6d8b7c0506a7.png)\n",
    "\n",
    "③ 当出现“Successfully instll”，则表示安装成功！\n",
    "\n",
    "### Ⅱ Pycharm中jieba库的安装：\n",
    "\n",
    "打开 settings，搜索 Project Interpreter，在右边的窗口选择 + 号，点击后在搜索框搜索 jieba，点击安装即可。具体过程如图：\n",
    "\n",
    "①  点击左上角Files中的Settings：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-c13078d5e4724bb4.png)\n",
    "\n",
    "②  \\[endif\\]找到“Project”中的“python interpreter”，并点击其中的“+”：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-0a357ed2b76f98c5.png)\n",
    "\n",
    "③在搜索栏中搜索“jieba”，并点击左下角Install Package：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-1ebda5de9c20fbd8.png)\n",
    "\n",
    "④ 当出现“Successfully instll\n",
    "\n",
    "jieba”，则表示jieba库安装成功！\n",
    "\n",
    "#### 四：实例-文本词频统计\n",
    "\n",
    "Jieba库最强大的功能之一就是对文章出现的词汇进行计数统计，即计算词频，对于一篇文章或者一部著作，我们可以通过以下步骤对出现的单词进行统计：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-041acc63529a9a0e.png)\n",
    "\n",
    "源代码："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-d6f432333e0c663d.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "曹躁        :  832\n",
      "孔明        :  831\n",
      "将军        :  757\n",
      "却说        :  645\n",
      "玄德        :  568\n",
      "关公        :  509\n",
      "丞相        :  487\n",
      "二人        :  465\n",
      "不可        :  435\n",
      "荆州        :  420\n",
      "孔明曰       :  385\n",
      "玄德曰       :  383\n",
      "不能        :  382\n",
      "如此        :  376\n",
      "张飞        :  348\n"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "txt = open(\"三国演义.txt\", \"r\",encoding=\"utf-8\").read()\n",
    "words = jieba.lcut(txt)\n",
    "counts = {}\n",
    "for word in words:\n",
    "    if len(word) == 1:\n",
    "        continue\n",
    "    else:\n",
    "        counts[word] = counts.get(word, 0) + 1\n",
    "items = list(counts.items())\n",
    "items.sort(key=lambda x: x[1], reverse=True)\n",
    "for i in range(15):\n",
    "    word, count = items[i]\n",
    "    print(f\"{word:<10}:{count:>5}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "注：\n",
    "\n",
    "①  encoding=’ANSI’:将打开的文本格式设为ANSI形式\n",
    "\n",
    "②  read(size):方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，它范围为字符串对象。\n",
    "\n",
    "③items\n",
    "\n",
    "\\= list（counts.items）:将counts中的元素存入items表格中。\n",
    "\n",
    "④  key = lambda x:x\\[1\\]:等价于 def func(x):\n",
    "\n",
    "                                                          return x\\[1\\]\n",
    "\n",
    "⑤ reverse = True：列**表反转排序，**不写reverse = True 就是列表升序排列，括号里面加上reverse =True 就是降序排列！\n",
    "\n",
    "**⑥**  {word:<10}{count:>5}:**<****表示左对齐，>表示右对齐，数字表示宽度,<10表示左对齐，并占10个位置，>5表示右对齐，占5个位置。**\n",
    "\n",
    "如上运行结果有两个不足之处，一是词汇中出现了“却说”、“丞相”、“二人”等人名以外的单词，我们需要把这些单词去除；二是“孔明”与“孔明说”、“曹操”与“丞相”等的是同一人，我们需要把它们合并同类项，将代码进行优化后，我们得到："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "孔明        : 1373\n",
      "曹躁        :  832\n",
      "玄德        :  568\n",
      "关公        :  509\n",
      "丞相        :  487\n",
      "玄德曰       :  383\n",
      "张飞        :  348\n",
      "商议        :  344\n",
      "如何        :  336\n",
      "主公        :  327\n",
      "军士        :  309\n",
      "吕布        :  300\n",
      "大喜        :  296\n",
      "左右        :  291\n",
      "军马        :  289\n"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "excludes = {\"将军\", \"却说\", \"荆州\", \"二人\", \"不可\", \"不能\", \"如此\"}\n",
    "txt = open(\"三国演义.txt\", \"r\", encoding=\"utf-8\").read()\n",
    "words = jieba.lcut(txt)\n",
    "counts = {}\n",
    "for word in words:\n",
    "    if len(word) == 1:\n",
    "        continue\n",
    "    elif word == \"诸葛亮\" or word == \"孔明曰\":\n",
    "        rword = \"孔明\"\n",
    "        \n",
    "    else:\n",
    "        rword = word\n",
    "    counts[rword] = counts.get(rword, 0) + 1\n",
    "for word in excludes:\n",
    "    del counts[word]\n",
    "items = list(counts.items())\n",
    "items.sort(key=lambda x: x[1], reverse=True)\n",
    "for i in range(15):\n",
    "    word, count = items[i]\n",
    "    print(f\"{word:<10}:{count:>5}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "相对于第一个程序，这个程序更为严谨与完整，已经得到了大致得到所需结果，但它还没有完全解决排除非人名这一问题，所以在该基础之上继续使用排除人名的方法去完善这一程序……\n",
    "\n",
    "#### 总结：\n",
    "\n",
    "使用jieba库对一段文本进行词频的统计是一件非常有意思的事，我们只需要使用这第三方库，就可以在不阅读文本的情况下，得到该文本的高频率词汇。但jieba库的作用远远不止于此，它更多的作用等着我们去挖掘。总的来说，jieba库是一个优秀的中文分词第三方库，它在我们的程序中正大放光芒！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pd.DataFrame(data = items).to_csv(r\"三国演义.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 1\\. 安装 wordcloud 模块\n",
    "\n",
    "1.  网络正常情况下命令行输入`pip install wordcloud`,如果提示报错按以下步骤进行安装\n",
    "\n",
    "```\n",
    "pip install wordcloud\n",
    "```\n",
    "\n",
    "2.  **pip**安装**wordcloud**过程中提示pip工具版本低,需pip-10.0.1版本，需先更新pip包管理工具：\n",
    "\n",
    "```\n",
    "python -m pip install --upgrade pip\n",
    "```\n",
    "\n",
    "3.  **pip**更新到最新版本后还是安装**wordcloud**报错\n",
    "\n",
    "先下载`wordcloud‑1.4.1‑cp36‑cp36m‑win_amd64.whl`安装包到本地目录, python为3.6.x版本的下载cp36的包，注意不要下cp37，安装不了的。\n",
    "\n",
    "4.  打开[命令行](https://so.csdn.net/so/search?q=%E5%91%BD%E4%BB%A4%E8%A1%8C&spm=1001.2101.3001.7020)窗口，进入到安装包所在目录位置如 `D:\\download`\n",
    "\n",
    "5.  输入\n",
    "\n",
    "\n",
    "```\n",
    "pip install wordcloud-1.4.1-cp36-cp36m-win_amd64.whl\n",
    "```\n",
    "\n",
    "回车安装即可。\n",
    "\n",
    "## 2\\. wordcloud 简介\n",
    "\n",
    "**wordcloud** 库把词云当作一个**WordCloud**对象\n",
    "\n",
    "-   `wordcloud.WordCloud()` 代表一个文本对应的词云\n",
    "-   可以根据文本中词语出现的频率等参数绘制词云\n",
    "-   绘制词云的形状、尺寸和颜色均可设定\n",
    "-   以WordCloud对象为基础，配置参数、加载文本、输出文件\n",
    "\n",
    "```\n",
    "c = wordcloud.WordCloud()  # 配置对象参数\n",
    "c.generate(\"wordcloud by python\")  # 加载词云文本\n",
    "c.to_file(\"pywordcloud.png\")  # 输出词云文件\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from wordcloud import WordCloud\n",
    "c = WordCloud(font_path='simhei.ttf').generate(\"中文 by 测试\")\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(c)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/b67ddd1295964bce94a842c7318f90f2.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "## 3\\. wordcloud 如何将文本转化为词云\n",
    "\n",
    "1.  **分隔**：以空格分隔单词\n",
    "2.  **统计**：单词出现次数并过滤\n",
    "3.  **字体**：根据统计配置字号\n",
    "4.  **布局**：颜色环境尺寸\n",
    "\n",
    "## 4\\. WordCloud(<参数>)介绍\n",
    "\n",
    "1.  **width**：指定词云对象生成图片的宽度,默认400像素\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(width=600)\n",
    "```\n",
    "\n",
    "2.  **height**：指定词云对象生成图片的高度,默认200像素\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(height=400)\n",
    "```\n",
    "\n",
    "3.  **min\\_font\\_size**：指定词云中字体的最小字号，默认4号\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(min_font_size=10)\n",
    "```\n",
    "\n",
    "4.  **max\\_font\\_size**：指定词云中字体的最大字号，根据高度自动调节\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(max_font_size=20)\n",
    "```\n",
    "\n",
    "5.  **font\\_step**：指定词云中字体字号的步进间隔，默认为1\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(font_step=2)\n",
    "```\n",
    "\n",
    "6.  **font\\_path**：指定文体文件的路径，默认None\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(font_path=\"msyh.ttc\")\n",
    "```\n",
    "\n",
    "7.  **max\\_words**：指定词云显示的最大单词数量,默认200\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(max_words=20)\n",
    "```\n",
    "\n",
    "8.  **stop\\_words**：指定词云的排除词列表，即不显示的单词列表\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(stop_words=\"Python\")\n",
    "```\n",
    "\n",
    "9.  **mask**：指定词云形状，默认为长方形，需要引用`imread()`函数\n",
    "\n",
    "```\n",
    "from scipy.msc import imread\n",
    "\n",
    "mk=imread(\"pic.png\")\n",
    "w=wordcloud.WordCloud(mask=mk)\n",
    "```\n",
    "\n",
    "10.  **background\\_color**：指定词云图片的背景颜色，默认为黑色\n",
    "    `w=wordcloud.WordCloud(background_color=\"white\")`\n",
    "\n",
    "**示例：**\n",
    "\n",
    "```\n",
    "text = \"life is short, you need python\"\n",
    "\n",
    "w = wordcloud.WordCloud(background_color=\"white\")  # 把词云当做一个对象\n",
    "w.generate(text)\n",
    "w.to_file(\"pywordcloud2.png\")\n",
    "```\n",
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/61ca7cc86734439bb15d16f306715525.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "## 5\\. 词云绘制1\n",
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/8626af9271b04d39937d7fdfc53c7841.png)\n",
    "\n",
    "`关于实施乡村振兴战略的意见.txt`\n",
    "\n",
    "```\n",
    "import jieba\n",
    "import imageio\n",
    "from wordcloud import WordCloud\n",
    "\n",
    "'''\n",
    "jieba支持三种分词模式：\n",
    "    精确模式lcut()，试图将句子最精确地切开，适合文本分析，单词无冗余；\n",
    "    全模式lcut(s, cut_all=True) ，把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义，存在冗余；\n",
    "    搜索引擎模式cut_for_search(s)，在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。\n",
    "'''\n",
    "\n",
    "with open(\"关于实施乡村振兴战略的意见.txt\", \"r\") as f:\n",
    "    allSentence = f.read()\n",
    "\n",
    "print(allSentence)\n",
    "\n",
    "re_move = ['，', '。', '\\n', '\\xa0', '-', '(', ')']  # 无效数据\n",
    "\n",
    "# 去除无关数据\n",
    "for i in re_move:\n",
    "    allSentence = allSentence.replace(i, \"\")\n",
    "\n",
    "pureWord = jieba.lcut(allSentence)\n",
    "\n",
    "with open(\"pureRuralRevitalieztion.txt\", \"w\") as f:\n",
    "     for i in pureWord:\n",
    "         f.write(str(i)+\" \")  # == ' '.join(pureWord)，以空格拼接list中元素\n",
    "\n",
    "with open(\"pureRuralRevitalieztion.txt\", \"r\") as f:\n",
    "    pureWord = f.read()\n",
    "\n",
    "# 获取一张背景图片\n",
    "mask = imageio.imread(\"chinamap.jpg\")\n",
    "word = WordCloud(background_color=\"white\",\\\n",
    "                    width=800,\\\n",
    "                   height=800,\n",
    "                   font_path='simhei.ttf',\n",
    "                   mask=mask,\n",
    "                   ).generate(pureWord)\n",
    "\n",
    "word.to_file('乡村振兴词云.png')\n",
    "\n",
    "# with open(\"pureRuralRevitalieztion.txt\", \"w\") as f:\n",
    "#     for i in pureWord:\n",
    "#         f.write(i+\" \")\n",
    "#\n",
    "#\n",
    "# c = wordcloud.WordCloud()  # 配置对象参数\n",
    "# c.generate(allSentence)\n",
    "# c.to_file(\"ruralRevitalieztion.png\")\n",
    "```\n",
    "\n",
    "## 6\\. 词云绘制2\n",
    "\n",
    "`新时代中国特色社会主义.txt`\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/f6d5900b1fb34e78b91eeb60e3938df0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "```\n",
    "import jieba\n",
    "import imageio\n",
    "from wordcloud import WordCloud\n",
    "\n",
    "with open(\"新时代中国特色社会主义.txt\", \"r\") as f:\n",
    "    allSentence = f.read()\n",
    "\n",
    "print(allSentence)\n",
    "\n",
    "re_move = ['，', '。', '\\n', '\\xa0', '-', '(', ')']  # 无效数据\n",
    "\n",
    "# 去除无关数据\n",
    "for i in re_move:\n",
    "    allSentence = allSentence.replace(i, \"\")\n",
    "\n",
    "pureWord = jieba.lcut(allSentence)\n",
    "\n",
    "with open(\"pureChinaDevelop.txt\", \"w\") as f:\n",
    "     for i in pureWord:\n",
    "         f.write(str(i)+\" \")\n",
    "\n",
    "with open(\"pureChinaDevelop.txt\", \"r\") as f:\n",
    "    pureWord = f.read()\n",
    "\n",
    "mask = imageio.imread(\"chinamap.jpg\")\n",
    "word = WordCloud(background_color=\"black\",\n",
    "                   width=800,\n",
    "                   height=800,\n",
    "                   font_path='simhei.ttf',\n",
    "                   mask=mask,\n",
    "                   ).generate(pureWord)\n",
    "\n",
    "word.to_file('新时代中国词云.png')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# 插入空格把词语分开\n",
    "items = items[:15]\n",
    "wc = []\n",
    "for item in items:\n",
    "    wc.append(item[0])\n",
    "wl_split=' '.join(wc)\n",
    "# 调用generate()方法生成词云\n",
    "from wordcloud import WordCloud\n",
    "mywc = WordCloud(font_path='simhei.ttf').generate(wl_split)\n",
    "mywc.to_file(\"三国词云.png\")\n",
    "# 显示词云\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(mywc)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
